import sys
import os
import argparse
import logging
from pathlib import Path

# 设置项目根目录路径并加入搜索路径
BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../"))
if BASE_DIR not in sys.path:
    sys.path.insert(0, BASE_DIR)

# 导入模块
from src.preprocessing.country_utils import read_country_list
from src.preprocessing.file_processor import process_file, validate_country_codes

def setup_logging(log_level=logging.INFO, log_file=None):
    """设置日志系统"""
    logging.basicConfig(
        level=log_level,
        format='%(asctime)s - %(levelname)s - %(message)s',
        handlers=[
            logging.StreamHandler(sys.stdout),
            (log_file and logging.FileHandler(log_file)) or None
        ]
    )
    return logging.getLogger()

def process_file_with_progress(file_path, country_dict, output_dir, dry_run=False):
    """处理单个文件并显示进度
    
    参数:
        file_path: 要处理的文件路径
        country_dict: 国家映射字典
        output_dir: 输出目录
        dry_run: 预览模式，不实际写入文件
        
    返回:
        字典: 处理结果信息
    """
    try:
        # 验证国家代码
        if not all(code in country_dict for code in country_dict):
            missing = [code for code in country_dict if code not in country_dict]
            raise ValueError(f"发现{len(missing)}个未在国家列表中注册的国家代码: {missing}")
        
        # 处理文件
        result = process_file(file_path, country_dict, output_dir, dry_run=dry_run)
        
        # 显示进度
        print(f"✅ 已处理: {os.path.basename(file_path)}")
        return {
            'success': True,
            'file': os.path.basename(file_path),
            'message': f"成功转换, 生成 {len(result)} 个新文件"
        }
        
    except Exception as e:
        print(f"❌ 错误处理文件 {os.path.basename(file_path)}: {str(e)}")
        return {
            'success': False,
            'file': os.path.basename(file_path),
            'error': str(e)
        }

def process_all_files(
    input_dir,
    country_list_path,
    output_dir,
    file_format='csv',
    recursive=False,
    dry_run=False,
    max_workers=None
):
    """处理目录中所有符合条件的文件
    
    参数:
        input_dir: 输入目录路径
        country_list_path: 国家映射文件路径
        output_dir: 输出目录路径
        file_format: 国家映射文件格式，默认'csv'
        recursive: 是否递归处理子目录
        dry_run: 预览模式，不实际写入文件
        max_workers: 并发处理的工作进程数
        
    返回:
        字典: 处理总结报告
    """
    # 创建输出目录
    os.makedirs(output_dir, exist_ok=True)
    
    # 读取国家列表
    country_dict = read_country_list(country_list_path, file_format=file_format)
    
    # 验证国家字典
    if not validate_country_codes(country_dict):
        raise ValueError("国家代码验证失败，请检查国家映射文件的格式")
    
    # 收集所有文件
    processed_files = []
    
    if recursive:
        file_paths = []
        for root, _, files in os.walk(input_dir):
            for file in files:
                if file.endswith("_Indicators.xlsx"):
                    file_paths.append(os.path.join(root, file))
    else:
        file_paths = [os.path.join(input_dir, f) for f in os.listdir(input_dir) 
                   if f.endswith("_Indicators.xlsx")]
    
    if not file_paths:
        print("警告: 未找到任何匹配的文件 (.xlsx)")
        print(f"请确保文件以 '_Indicators.xlsx' 结尾，并位于 {input_dir}")
        return {
            'total_files': 0,
            'processed': 0,
            'failed': 0,
            'dry_run': dry_run
        }
    
    # 总计数
    print(f"发现 {len(file_paths)} 个匹配的文件")
    
    # 并行处理选项
    from concurrent.futures import ThreadPoolExecutor, as_completed
    
    success_count = 0
    error_count = 0
    
    # 处理每个文件
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_file = {executor.submit(process_file_with_progress, f, country_dict, output_dir, dry_run): f for f in file_paths}
        
        for future in as_completed(future_to_file):
            file_path = future_to_file[future]
            try:
                result = future.result()
                results.append(result)
                if result['success']:
                    success_count += 1
                else:
                    error_count += 1
            except Exception as e:
                print(f"处理文件 {file_path} 时发生异常: {str(e)}")
                error_count += 1
    
    # 生成摘要
    summary = {
        'total_files': len(file_paths),
        'processed': success_count,
        'failed': error_count,
        'dry_run': dry_run,
        'files': results
    }
    
    return summary

def main():
    """脚本主函数"""
    parser = argparse.ArgumentParser(description='处理指标文件并转换为处理后的格式')
    
    # 添加命令行参数
    parser.add_argument('--input-dir', '-i', type=str, required=True,
                        help='输入目录路径，包含 _Indicators.xlsx 文件')
    parser.add_argument('--country-list', '-c', type=str, required=True,
                        help='国家映射文件路径')
    parser.add_argument('--output-dir', '-o', type=str, required=True,
                        help='输出目录路径')
    parser.add_argument('--format', '-f', type=str, default='csv',
                        choices=['csv', 'json', 'yaml'],
                        help='国家映射文件格式，默认为 csv')
    parser.add_argument('--dry-run', '-d', action='store_true',
                        help='预览模式，不实际写入文件')
    parser.add_argument('--recursive', '-r', action='store_true',
                        help='递归处理所有子目录')
    parser.add_argument('--workers', '-w', type=int, default=None,
                        help='并发工作进程数')
    
    # 可选的日志参数
    parser.add_argument('--log-level', '-l', type=str, default='INFO',
                        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
                        help='日志级别')
    parser.add_argument('--log-file', '-F', type=str,
                        help='日志文件路径')
    
    args = parser.parse_args()
    
    # 设置日志
    log_level = getattr(logging, args.log_level.upper())
    logger = setup_logging(log_level, args.log_file)
    
    try:
        # 处理所有文件并获取总结
        summary = process_all_files(
            args.input_dir,
            args.country_list,
            args.output_dir,
            args.format,
            args.recursive,
            args.dry_run,
            args.workers
        )
        
        # 显示结果摘要
        print("\n📊 处理摘要:")
        print(f"总数: {summary['total_files']}")
        print(f"成功: {summary['processed']}")
        print(f"失败: {summary['failed']}")
        
        if not summary['dry_run'] and summary['processed'] > 0:
            print(f"✓ 所有处理后的文件已保存到: {args.output_dir}")
        elif summary['dry_run']:
            print("🔍 这是一个预览运行，没有实际文件被修改")
        
    except Exception as e:
        logger.exception(f"脚本执行过程中发生错误: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    sys.exit(main() or 0)

    process_all_files(input_directory, country_list_file, output_directory, file_format='csv')
